lesson1_knowledge_point = {
    "if 语句": ['理解意义，100（100）','具体操作,100(85)'],
        # if xxxxx :
        # elif xxxxx:
        # else:
        # 可以进行嵌套，不要超过3层，最多5层

    "for循环以及range内置函数": {
        "for循环": ['理解意义，100（90）', '具体操作,100(80)'],
        "range内置函数": ['range(stop),理解,100(100),操作,100(90)',
                      'range(start, stop[, step]),理解,100(100),操作,100(90)'
                      ],
        # for 循环
        # a=[1,2]
        # for b in a:
        # print(b)
        # 1 2
        # range内置函数（可创建一个整数列表，一般用在 for 循环中。）
        # start: 计数从 start 开始。默认是从 0 开始。
        # stop: 计数到 stop 结束，但不包括 stop。
        # step：步长，默认为1。
        # >>> range(1, 11)     从 1 开始到 11，步长为1，等价于range（1，11，1）
        # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]     输出结果
        "for循环和range内置函数结合": ['理解意义，100（80）', '具体操作,100(75)']
        # 循环出run 的每个字母
        # >>>x = 'run'
        # >>> for i in range(len(x)) :
        #        print(x[i])
        # r
        # u
        # n

    },
    "random函数学习": {
        'random.random()': ['理解意义，100（100）', '具体操作,100(100)'],
        # random() 方法返回随机生成的一个实数，它在[0,1)范围内。
        # random()是不能直接访问的，需要导入 random 模块，然后通过 random 静态对象调用该方法。
        # import random
        # print "random() : ", random.random()  #生成第一个随机数
        # print "random() : ", random.random()  #生成第二个随机数
        # random() :  0.281954791393
        # random() :  0.309090465205
        'random.randint(a,b)': ['理解意义，100（100）', '具体操作,100(100)'],
        # 用于生成一个指定范围内的整数。其中参数a是下限，参数b是上限，生成的随机数n: a <= n <= b
        # import random
        # a=print random.randint(1,50)
        # print(a)
        # 25
        'random.random(a,b)': ['理解意义，100（100）', '具体操作,100(100)'],
        # 随机浮点数
        # import random
        # a = random.uniform(1, 10)
        # print(a)
        # 4.446502670203006
        'random.uniform(a,b)': ['理解意义，100（100）', '具体操作,100(90)'],
        # 用于生成一个指定范围内的随机符点数，两个参数其中一个是上限，一个是下限。如果a > b，则生成的随机数n: a <= n <= b。如果 a <b， 则 b <= n <= a。
        # import random
        # a=random.randrange(10, 20)
        # b= random.uniform(20, 10)
        # print(a)
        # print(b)
        # 18.7356606526
        # 12.5798298022
        'random.randrange([start], stop[, step])': ['理解意义，100（90）', '具体操作,100(90)'],
        # 从指定范围内，按指定基数递增的集合中 获取一个随机数。
        # 如：random.randrange(10, 100, 2)，结果相当于从[10, 12, 14, 16, ... 96, 98]序列中获取一个随机数。random.randrange(10, 100, 2)在结果上与 random.choice(range(10, 100, 2) 等效。
        'random.choice(sequence)': ['理解意义，100（90）', '具体操作,100(50)'],
        # 从序列中随机选取一个元素,参数sequence表示一个有序类型。
        'random.shuffle': ['理解意义，100（50）', '具体操作,100(0)'],  # 没有练习过该方法
        # 用于将一个列表中的元素打乱。
        'random.sample(sequence, k)': ['理解意义，100（50）', '具体操作,100(0)'],  # 没有练习过该方法
        # 从指定的序列中随机获取指定长度的片断并随机排列，sample函数不会修改原有序列

    },
},

lesson2and3_knowledge_point = {
    '字符串': {
        '字符串的拼接': ['理解意义，100（80）', '具体操作,100(70)'],
        "''.join()": ['理解意义，100（80）', '具体操作,100(70)'],
        # 用于字符串的拼接
        # strlist=['Python', '，', '你好', '！']
        # print(''.join(strlist))
        # Python，你好！
        'str.split（）': ['理解意义，100（80）', '具体操作,100(70)'],
        # 用于对字符串进行拆分
        # a='1,2,3'
        # b=a.split(',')
        # print(b)
        # ['1','2','3']
        'str.count()': ['理解意义，100（100）', '具体操作,100(90)'],
        # 计算字符串某个数值出现的次数
        # a='1,2,3,1'
        # print(a.count('1'))
        # 2
        'str.isdigit': ['理解意义，100（50）', '具体操作,100(0)'], # 没有练习过该方法
        # 如果字符串只包含数字则返回 True，否则返回 False。
        # a='123'
        # print(a.isdigit)
        # True
    },

     '列表': {
         '索引和切片': ['理解意义，100（90）', '具体操作,100(85)'],
           # list1=[1,2,3,'string',[1,2,3]]
           # 索引
           # print(list1[3])
           # print(list1[3][2])
           # 切片
           # print(list1[0:5:2])
           # print(list1[::-1])
         '添加元素': {
             'append()': ['理解意义，100（100）', '具体操作,100(85)'],
              # str1=[1,2,3,'string',[1,2,3]]
              # append():在列表最后一位添加元素
              # print(str1.append('zjj')
             'insert()': ['理解意义，100（100）', '具体操作,100(80)'],
              # insert():在列表中插入元素
              # print(list1.insert(0,'zjj'))
         '删除列表元素': ['理解意义，100（100）', '具体操作,100(80)'],
             'pop()': ['理解意义，100（100）', '具体操作,100(70)']
              # list1=[1,2,3,'string','[1,2,3]]
              # pop()：弹出最后一个元素，这个元素还可以再利用
              # print(list1.pop())
             },
             'remove()': ['理解意义，100（90）', '具体操作,100(80)'],
              #移除指定的元素，该元素也可再利用，在移去之前复制给变量
              #print(list1.remove('zjj'))
             'del()':['理解意义，100（80）', '具体操作,100(70)'],
              #print(str1.del(0))
         '查找':['理解意义，100（80）', '具体操作,100(80)'],
              # 'in,not in'
              # list1=[1,2,3,'string',[1,2,3]]
              # print(1 in list1)
              # print(1 not in list1)
         '统计变换':['理解意义，100（100）', '具体操作,100(80)'],
              # list1=[1,2,3,'string',[1,2,3]]
              # len():返回list1元素的个数，字符串也可以用该函数
              # print(len(list1))
              # max():返回元素中最大的，如实字母，则按一定字母顺序，选择靠后的,若既有数字型又有字符串型，则报错
              # print(max(list1))
              # min():返回元素中最小的，如实字母，则按一定字母顺序，选择靠前的,若既有数字型又有字符串型，则报错
              # print(min(list1))
         '重要函数':['理解意义，100（50）', '具体操作,100(0)'],  # 没有练习过该方法
              # list1=[1,5,8,32,2,7,0]
              # reverse():逆转函数，直接改变原有列表
              # print(list1.reverse())
              # sort(reverse=True)#默认升序
              # print(list1.sort())
              # print(list1.sort(reverse=False))
              # copy()复制函数
              # list2=list1.copy()
              # print(list2)
              # clear():清空列表
              # list1.clear()
              # print(list1)
          '其他函数':['理解意义，100（60）', '具体操作,100(30)'],
              # list1=[1,4,2,1,3,7,8,1]
              # list2=['string','zjj']
              # extend():
              # list2.extend(list1)  # 打印这个返回 None
              # print(list2)
              # 结果返回为：['string','zjj',1,4,2,1,3,7,8,1]
              # count()
              # print(list1.count(1))
              # index()  # 返回对应元素的索引，若有多个相同元素，只返回第一个找到的元素。没找到就报错
              # print(list1.index(1))
              # 返回结果为 0
     },
    '字典':{
        '创建字典':['理解意义，100（100）', '具体操作,100(80)'],
        #dict1 = { 'abc': 456 }
        #dict2 = { 'abc': 123, 98.6: 37 }
        '访问字典里的值':['理解意义，100（100）', '具体操作,100(100)'],
        #dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
        #print "dict['Name']: ", dict['Name']
        #print "dict['Age']: ", dict['Age']
        #dict['Name']:  Zara
        #dict['Age']:  7
        '修改字典':['理解意义，100（100）', '具体操作,100(100)'],
        # dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
        # dict['Age'] = 8  # 更新
        # dict['School'] = "RUNOOB"  # 添加
        # print
        # "dict['Age']: ", dict['Age']
        # print
        # "dict['School']: ", dict['School']
        '删除字典元素':['理解意义，100（100）', '具体操作,100(100)'],
        #dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
        #del dict['Name']  # 删除键是'Name'的条目
        #dict.clear()      # 清空字典所有条目
        #del dict          # 删除字典
        #print "dict['Age']: ", dict['Age']
        #print "dict['School']: ", dict['School']
        '遍历字典':['理解意义，100（80）', '具体操作,100(70)'],
        #user_0={
        #'username':'efermi',
        #'first':'enrico',
        #'last':'fermi',
        #}
        #for key,value in user_0.items():
        #print("\nkey: "+key)
        #print("value： "+value）
        '字典内置函数&方法':{
            '内置函数':['理解意义，100（80）', '具体操作,100(60)'],
            #内置函数cmp(dict1, dict2)，len(),str(),type()
            #使用了 items、values、keys 返回的是可迭代对象，可以使用 list 转化为列表。
            #len(字典名)：返回键的个数，即字典的长度
            #dic = {'a':123,'b':456,'c':789,'d':567}
            #print(len(dic))
            #4
            #str(字典名)：将字典转化成字符串
            #dic = {'a':123,'b':456,'c':789,'d':567}
            #print(str(dic))
            # {'a': 123, 'b': 456, 'c': 789, 'd': 567}
            #type(字典名)：查看字典的类型
            #dic = {'a':123,'b':456,'c':789,'d':567}
            #print(type(dic))
            #<class 'dict'>
            '内置方法':['理解意义，100（70）', '具体操作,100(50)'],
            # clear( )：
            # 删除字典内所有的元素
            # dic = {'a':123,'b':456,'c':789,'d':567}
            # dic.clear()
            # print(dic)
            # {}
            # copy( )：
            # 拷贝一个字典
            #dic = {'a':123,'b':456,'c':789,'d':567}
            #dic_two = dic.copy()
            #print(dic)
            # {'a': 123, 'b': 456, 'c': 789, 'd': 567}
            # print(dic_two)
            # {'a': 123, 'b': 456, 'c': 789, 'd': 567}
            # fromkeys(seq[,value])：创建一个新字典,seq作为键，value为字典所有键的初始值(默认为None)
            #dic = dict.fromkeys('abcd')
            # 默认为 None
            #print(dic)
            # {'a': None, 'b': None, 'c': None, 'd': None}
            #dic = dict.fromkeys('abc',1)
            # print(dic)
            # {'a': 1, 'b': 1, 'c': 1}
            # get(key,default = None)：返回指定的键的值，如果键不存在，则返会 default 的值
            #dic = {'a':1,'b':2,'c':3,'d':4}
            #print(dic.get('b'))
            # 2
            # print(dic.get('e',5))
            # 5
            # items( )：以列表返回可遍历的(键值对)元组 的值
            #dic = {'a':1,'b':2,'c':3,'d':4}
            #print(dic.items())
            # dict_items([('a', 1), ('b', 2), ('c', 3), ('d', 4)])
            # print(list(dic.items()))
            # [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
            # keys( )：返回一个迭代器，可以使用 list() 来转换为列表
            #dic = {'a':1,'b':2,'c':3,'d':4}
            #print(dic.keys())
            #dict_keys(['a', 'b', 'c', 'd'])
            # print(list(dic.keys()))
            # ['a', 'b', 'c', 'd']
            # setdefault(key,default = None)：
            # 如果键存在，则不修改键的值
            #dic = {'a':1,'b':2,'c':3,'d':4}
            #dic.setdefault('a',8)
            # print(dic)
            # {'a': 1, 'b': 2, 'c': 3, 'd': 4}
            # update(字典对象)：
            # 将字典对象更新到字典中
            #dic = {'a':1,'b':2,'c':3,'d':4}
            #dic_two = {'f':6}
            #dic.update(dic_two)
            #print(dic)
            # {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'f': 6}
            # values( )：
            # 使用 list 转换为字典中 值 的列表
            #dic = {'a':1,'b':2,'c':3,'d':4}
            #print(list(dic.values()))
            # pop(key[,default])：
            # 删除字典中 key 的值，返回被删除的值。key 值如果不给出，则返回default的值
            #dic = {'a':1,'b':2,'c':3,'d':4}
            #print(dic.pop('a',6))
            # 1 , 返回删除的值
            #print(dic)
            # {'b': 2, 'c': 3, 'd': 4}
            #print(dic.pop('e','字典中没有该值'))
            # 字典中没有该值 ， 如果字典中不存在该键，则返回 default 的值
            #print(dic)
            # {'b': 2, 'c': 3, 'd': 4}
            # popitem( )：
            # 随机返回一个键值对(通常为最后一个)，并删除最后一个键值对
            #dic = {'a':1,'b':2,'c':3,'d':4}
            #print(dic.popitem())
            # ('d', 4)
            #print(dic)
            # {'a': 1, 'b': 2, 'c': 3}
            #print(dic.popitem())
            # ('c', 3)
            #print(dic)
            # {'a': 1, 'b': 2}

         },
        '字典的键入形式':['理解意义，100（100）', '具体操作,100(80)'],
        '字典的嵌套':['理解意义，100（90）', '具体操作,100(70)'],
        '字典的频度计数引用':['理解意义，100（100）', '具体操作,100(80)'],
        '迭代处理字典':['理解意义，100（80）', '具体操作,100(60)'],
    },
    '集合':{
        # 集合（set）是一个无序的不重复元素序列。可以使用大括号 { } 或者 set() 函数创建集合
        '添加元素':['理解意义，100（100）', '具体操作,100(100)'],
        #>>> s = {1, 2, 3, 4, 5, 6}
        #>>> s.add("s")
        #>>> s
        #{1, 2, 3, 4, 5, 6, 's'}
        '清空集合':['理解意义，100（100）', '具体操作,100(100)'],
        #>>> s = {1, 2, 3, 4, 5, 6}
        #>>> s.clear()
        #>>> s
        #set()
        '返回集合的浅拷贝':['理解意义，100（100）', '具体操作,100(90)'],
        #>>> s = {1, 2, 3, 4, 5, 6}
        #>>> new_s = s.copy()
        #>>> new_s
        #{1, 2, 3, 4, 5, 6}
        '删除并返回任意的集合元素':['理解意义，100（80）', '具体操作,100(70)'],
        #>>> s = {1, 2, 3, 4, 5, 6}
        #>>> s.pop()　　# pop删除时是无序的随机删除
        #1
        #>>> s
        #{2, 3, 4, 5, 6}
        '删除集合中的一个元素':['理解意义，100（100）', '具体操作,100(50)'],  # 没怎么练习过该方法
        #>>> s = {1, 2, 3, 4, 5, 6}
        #>>> s.remove(3)  #s.discard("sb")
        #>>> s
        #{1, 2, 4, 5, 6}
        '将两个集合的交集作为一个新集合返回':['理解意义，100（100）', '具体操作,100(0)']  # 没有练习过该方法
        #intersection
        #union 将集合的并集作为一个新集合返回
        #difference 将两个或多个集合的差集作为一个新集合返回　
        #symmetric_difference 将两个集合的对称差作为一个新集合返回(两个集合合并删除相同部分，其余保留)
        #update 用自己和另一个的并集来更新这个集合
        #intersection_update()  用自己和另一个的交集来更新这个集合
        #isdisjoint() 　如果两个集合有一个空交集，返回 True
        #issubset()　如果另一个集合包含这个集合，返回 True
        #issuperset() 　如果这个集合包含另一个集合，返回 True
        #difference_update() 从这个集合中删除另一个集合的所有元素
        #symmetric_difference_update() 用自己和另一个的对称差来更新这个集合
        '集合与内置函数':['理解意义，100（70）', '具体操作,100(60)'],
    },
},
lesson4_knowledge_point={
    '函数的初步学习':{
        '函数关键字def return':['理解意义，100（80）','具体操作,100(60)'],
        '函数两种添加注释方法':['理解意义，100（90）','具体操作,100(70)'],
        '函数的*args用法':['理解意义，100（80）','具体操作,100(60)'],
        '函数的**kwargs用法':['理解意义，100（80）','具体操作,100(60)'],
        '函数的调用 import':['理解意义，100（100）','具体操作,100(90)'],
        '函数的as用法':['理解意义，100（100）','具体操作,100(90)'],
        '从模块中导入函数':['理解意义，100（80）','具体操作,100(70)'],
    }
}















